package com.by.service.impl;

import com.by.bean.Contacts;
import com.by.bean.Supplier;
import com.by.bean.User;
import com.by.common.crud.BaseServiceImpl;
import com.by.common.utils.AssertUtils;
import com.by.mapper.ContactsMapper;
import com.by.mapper.SupplierMapper;
import com.by.common.fileService.FileUploadService;
import com.by.mapper.UserMapper;
import com.by.service.SupplierService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.io.Serializable;
import java.util.NoSuchElementException;

/**
 * @author Ye QS
 * @version 0.1
 * @className CustomerServiceImpl
 * @description
 * @date 2024/9/13 17:17
 * @since jdk11
 */
@Service
public class SupplierServiceImpl extends BaseServiceImpl<Supplier, SupplierMapper> implements SupplierService {
    @Autowired
    SupplierMapper supplierMapper;
    @Autowired
    ContactsMapper salesMapper;

    @Autowired
    FileUploadService fileUploadService;
    @Autowired
    UserMapper userMapper;
    @Autowired
    ContactsMapper contactsMapper;
//    /**
//     * 保存供应商信息及其相关的销售信息
//     * 此方法使用了事务管理，确保供应商和其销售信息的保存操作都在同一个事务中完成
//     * 如果销售信息保存失败，会抛出异常并提示详细的错误信息
//     *
//     * @param entity 要保存的供应商对象，包含相关的销售信息
//     * @return 保存操作的结果，通常表示保存成功的记录数
//     */
//    @Transactional
//    @Override
//    public int save(Supplier entity) {
//        // 获取 Supplier 对象中的 Sales 对象
//        Contacts contacts = entity.getContacts();
//
//        // 保存 Sales 数据
//        int rs = salesMapper.save(contacts);
//
//        // 检查 Sales 数据是否保存成功
//        if (rs <= 0) {
//            // 如果保存失败，抛出自定义异常，并附带详细的错误信息
//            AssertUtils.isNotSuccess(rs, "联系人保存失败");
//        }
//
//        // 在确认 Sales 数据已成功保存后，再保存 Supplier 数据
//        return super.save(entity);
//    }

    /**
     * 保存供应商信息及其相关的文件上传
     *
     * @param entity  供应商实体对象
     * @param license 营业执照文件
     * @param logo    商标文件
     * @return 返回保存供应商信息的结果
     * @throws IOException 如果文件上传过程中发生IO错误
     */
    @Transactional
    @Override
    public int save(Supplier entity, MultipartFile license, MultipartFile logo) throws IOException {
        // 上传营业执照文件
        if (license != null && !license.isEmpty()) {
            String licensePath = fileUploadService.uploadFile(license, "licensePath");
            entity.setLicense(licensePath);
        }

        // 上传商标文件
        if (logo != null && !logo.isEmpty()) {
            String logoPath = fileUploadService.uploadFile(logo, "logo");
            entity.setLogo(logoPath);
        }

        // 获取 Supplier 对象中的 Contacts 对象
        Contacts contacts = entity.getContacts();

        // 保存 Contacts 数据
        int rs = salesMapper.save(contacts);

        // 检查 Contacts 数据是否保存成功
        if (rs <= 0) {
            // 如果保存失败，抛出自定义异常，并附带详细的错误信息
            AssertUtils.isNotSuccess(rs, "联系人保存失败");
        }

        // 在确认 Contacts 数据已成功保存后，再保存 Supplier 数据
        return super.save(entity);
    }

    @Override
    public int resetPassword(User user) {
        // 查询用户信息
        User userIdByAccount = userMapper.userIdByAccount(user.getUsername());

        if (userIdByAccount == null) {
            // 处理用户不存在的情况
            throw new NoSuchElementException("用户不存在");
        }

        // 创建新的 User 对象用于更新
        User updatedUser = new User();
        updatedUser.setId(userIdByAccount.getId()); // 假设 User 类中有 id 字段
        updatedUser.setUsername(user.getUsername());
        updatedUser.setPassword(user.getPassword());

        // 更新用户表
        return userMapper.update(updatedUser);
    }


    /**
     * 删除供货商及其关联联系人
     * 此方法通过供货商的ID先查询供货商信息，
     * 若供货商不存在，则抛出运行时异常；
     * 若供货商的联系人信息不完整，同样抛出运行时异常；
     * 在联系人信息完整的情况下，先删除联系人，然后删除供货商。
     *
     * @param id 供货商的ID
     * @return 删除操作的影响行数
     * @throws RuntimeException 当供货商不存在或联系人信息不完整时抛出
     */
    @Override
    @Transactional  // 添加事务注解，确保操作的原子性
    public int delete(Serializable id) {
        // 根据ID查询供货商信息
        Supplier supplierById = supplierMapper.getSupplierById(id);
        // 若供货商不存在，则抛出异常
        if (supplierById == null) {
            throw new RuntimeException("供货商不存在");
        }
        // 获取供货商的联系人信息
        Contacts contacts = supplierById.getContacts();
        // 若联系人信息不完整，则抛出异常
        if (contacts == null || contacts.getId() == null) {
            throw new RuntimeException("联系人信息不完整");
        }
        // 获取联系人的ID
        Integer contactsId = contacts.getId();

        // 删除联系人
        salesMapper.delete(contactsId);
        // 删除供货商，并返回影响行数
        return supplierMapper.delete(supplierById.getId());
    }


    /**
     * 更新供应商信息，包括供应商的客户和销售联系人信息
     * 这段代码的主要目的是更新供应商信息及其关联的联系人信息。以下是详细的步骤和逻辑：
     * 从供应商实体中提取用户信息
     * 从 Supplier 实体中获取 User 对象。获取用户的账号从 User 对象中获取 account 字段。
     * 根据账号查询用户信息
     * 使用 account 调用 userMapper.userIdByAccount(account) 方法查询用户信息。
     * 如果查询结果为空，抛出 IllegalArgumentException。
     * 提取用户ID
     * 从查询结果中获取 userId。根据用户ID查询供应商信息使用 userId
     * 调用 supplierMapper.getSupplierIdByUserId(userId) 方法查询供应商信息。
     * 如果查询结果为空，抛出 IllegalArgumentException。提取联系人ID
     * 从供应商信息中获取 contactsId。创建一个新的联系人对象创建一个 Contacts 对象。
     * 设置联系人信息设置联系人ID。设置销售联系人信息，从供应商实体中获取。设置销售联系电话，从供应商实体中获取。
     * 更新联系人信息调用 contactsMapper.update(contacts) 方法更新联系人信息。
     * 设置供应商实体的ID将查询到的供应商ID设置到 entity 中。
     * 更新供应商信息调用 supplierMapper.update(entity) 方法更新供应商信息，并返回影响的行数。
     * 异常处理
     * 在 try-catch 块中捕获异常，并抛出 RuntimeException。
     *
     * @param entity 要更新的供应商实体，包含用户和联系人信息
     * @return 更新操作的影响行数，用于判断更新是否成功
     */
    @Override
    public int update(Supplier entity) {
        // 从供应商实体中提取用户信息
        User user = entity.getUser();

        // 获取用户的账号
        String account = user.getUsername();

        // 根据账号查询用户信息
        User userIdByAccount = userMapper.userIdByAccount(account);

        if (userIdByAccount == null) {
            throw new IllegalArgumentException("User not found for account: " + account);
        }

        // 提取用户ID
        Integer userId = userIdByAccount.getId();

        // 根据用户ID查询供应商信息
        Supplier supplierId = supplierMapper.getSupplierIdByUserId(userId);

        if (supplierId == null) {
            throw new IllegalArgumentException("Supplier not found for user ID: " + userId);
        }

        // 提取联系人ID
        Integer contactsId = supplierId.getContactsId();

        // 创建一个新的联系人对象，用于更新销售联系人信息
        Contacts contacts = new Contacts();

        // 设置联系人ID
        contacts.setId(contactsId);

        // 设置销售联系人信息，从供应商实体中获取
        contacts.setSalesContact(entity.getContacts().getSalesContact());

        // 设置销售联系电话，从供应商实体中获取
        contacts.setSalesPhone(entity.getContacts().getSalesPhone());

        try {
            // 更新联系人信息
            contactsMapper.update(contacts);

            // 设置供应商实体的ID
            entity.setId(supplierId.getId());

            // 更新供应商信息，并返回影响的行数
            return supplierMapper.update(entity);
        } catch (Exception e) {
            // 异常处理
            throw new RuntimeException("Failed to update supplier", e);
        }
    }

}
